package com.tuling.sentinels.controller;

import com.alibaba.csp.sentinel.Entry;
import com.alibaba.csp.sentinel.EntryType;
import com.alibaba.csp.sentinel.SphU;
import com.alibaba.csp.sentinel.Tracer;
import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRule;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRuleManager;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import com.tuling.sentinels.pojo.User;
import lombok.extern.slf4j.Slf4j;
import org.omg.PortableInterceptor.USER_EXCEPTION;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.List;

/**
 * @author hzdc
 * @date 2022/5/14 8:24
 */
@RestController
@Slf4j
public class HelloController {

    public static final String RESOURCE_NAME = "hello";
    public static final String USER_RESOURCE_NAME = "user";
    public static final String DEGRADE_RESOURCE_NAME = "degrade";

    // 进行sentinel流控
    @RequestMapping(value = "/hello")
    public String hello() {
        Entry entry = null;
        try {
            // 针对资源限制
            entry = SphU.entry(RESOURCE_NAME);
            // 被保护的业务逻辑
            String str = "hello world";
            log.info("========" + str + "===========");
            return str;
        }
        catch (BlockException e) {
            // 资源访问阻止，被限流或被降级
            // 进行相应的处理操作
            log.info("block");
            return "被流控了";
        }
        catch (Exception ex) {
            // 若需要配置降级规则，需要通过这种方式记录业务异常
            Tracer.traceEntry(ex, entry);
        }
        finally {
            if (entry != null) {
                entry.exit();
            }
        }
        return null;
    }

    /**
     * 定义规则
     *
     * spring 的初始化方法
     */
    @PostConstruct
    private static void initFlowRules() {
        // 流控规则
        List<FlowRule> rules = new ArrayList<>(10);
        // 流控
        FlowRule rule = new FlowRule();
        // 设置受保护的资源
        rule.setResource(RESOURCE_NAME);
        // 设置流控规则 QPS
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        // 设置受保护的资源阈值
        // set limit OPS to 20
        rule.setCount(1); // 每秒访问一次
        rules.add(rule);

        // 通过@SentinelResource来定义资源并配置降级和流控的处理方法
        FlowRule rule2 = new FlowRule();
        rule2.setResource(USER_RESOURCE_NAME);
        rule2.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule2.setCount(1); // 每秒访问一次

        rules.add(rule2);

        // 加载配置好的规则
        FlowRuleManager.loadRules(rules);
    }

    /**
     * @SentinelResource 改善接口中资源定义和被流控降级后的处理方法 <br/>
     * 1.添加依赖 <artifactId>sentinel-annotation-aspectj</artifactId> <br/>
     * 2.配置bean-SentinelResourceAspect <br/>
     * value 定义资源 <br/>
     * blockHandler 设置 流控降级后的处理方法（默认该方法必须声明在同一个类），如果不想在同一个类中，blockHandlerClass，但方法必须是static
     *
     * fallback 当接口出现异常，可以交给fallback指定的方法进行处理，如果不想在同一个类中，fallbackClass，但方法必须是static
     *
     * blockHandler、fallback同时指定了，则blockHandler优先级更高
     *
     * exceptionsToIgnore 排除哪些异常不处理
     *
     * @return
     */
    @RequestMapping("/user")
    @SentinelResource(value = USER_RESOURCE_NAME,
            blockHandler = "blockHandlerForGetUser",
            fallback = "fallbackForGetUser")
    public User getUser() {
        int a = 10 / 0;
        return new User("李唐");
    }

    public User fallbackForGetUser(Throwable ex) {
        ex.printStackTrace();
        return new User("异常处理");
    }

    /**
     * 注意：<br/>
     * 1.一定要public <br/>
     * 2.返回值一定要和源方法保证一致,包含原方法的参数 <br/>
     * 3.可以在参数最后添加BlockException,可以区分是什么规则的处理方法 <br/>
     *
     * @param ex
     * @return
     */
    public User blockHandlerForGetUser(BlockException ex) {
        ex.printStackTrace();
        return new User("熔断降级");
    }

    @RequestMapping("/degrade")
    @SentinelResource(value = DEGRADE_RESOURCE_NAME, entryType = EntryType.IN, blockHandler = "blockHandlerForFb")
    public User degrade() {
        throw new RuntimeException("异常");
    }

    public User blockHandlerForFb(BlockException ex) {
        ex.printStackTrace();
        return new User("降级了！！！");
    }

    @PostConstruct
    public void initDegrade() {
        List<DegradeRule> degradeRules = new ArrayList<>(10);

        DegradeRule degradeRule = new DegradeRule();
        degradeRule.setResource(DEGRADE_RESOURCE_NAME);
        // 设置规则：异常数
        degradeRule.setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_COUNT);
        // 阈值，异常数2个
        degradeRule.setCount(2);
        // 触发熔断最小请求数：2
        degradeRule.setMinRequestAmount(2);
        // 统计时长：单位ms
        degradeRule.setStatIntervalMs(60*1000);
        // 1分钟内：执行了2次，出现了2次异常，就会触发熔断

        // 熔断持续时长： 单位秒
        // 一旦触发了熔断，再次请求对应的接口就会直接调用，降级方法
        // 10秒过后--半开状态：恢复接口请求调用，如果第一次请求就异常，再次熔断，不会根据设置的条件进行判断
        degradeRule.setTimeWindow(10);


        degradeRules.add(degradeRule);
        DegradeRuleManager.loadRules(degradeRules);
    }

}
